#ifndef THREADPOOL_H
#define THREADPOOL_H
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include<util.h>

class ThreadPool {
public:
    ThreadPool() : stop(false) {
        // 创建指定数量的工作线程
        for (int i = 0; i < getConfigInt("thread:max_thread"); ++i) {
            workerThreads.emplace_back([this]() {
                while (true) {
                    std::function<void()> task;

                    // 获取任务并执行
                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this]() {
                            return stop || !taskQueue.empty();
                        });

                        if (stop && taskQueue.empty()) {
                            return;
                        }

                        task = std::move(taskQueue.front());
                        taskQueue.pop();
                    }

                    task(); // 执行任务
                }
            });
        }
        std::cout<<"线程池初始化结束！"<<std::endl;
    }

    ~ThreadPool() {
        {
            std::lock_guard<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();

        // 等待所有工作线程完成
        for (std::thread& thread : workerThreads) {
            thread.join();
        }
    }

    // 提交任务到线程池
    template<class F, class... Args>
    void submit(F&& f, Args&&... args) {
        // 构造一个包装函数并将其加入任务队列
        auto task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);

        {
            std::lock_guard<std::mutex> lock(queueMutex);
            taskQueue.emplace(task);
        }
        condition.notify_one();
    }

private:
    std::vector<std::thread> workerThreads; // 工作线程
    std::queue<std::function<void()>> taskQueue; // 任务队列
    std::mutex queueMutex; // 互斥锁
    std::condition_variable condition; // 条件变量
    bool stop; // 标志是否停止
};

#endif // THREADPOOL_H
